/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package visual.ontogrator.pkg2;


import java.util.ArrayList;
import java.util.List;


/**
 *
 * @author Gabriel
 */
public class Network implements java.io.Serializable {
    ArrayList<List<String>> global = new ArrayList<>();
    ArrayList<List<List<Integer>>> no = new ArrayList<>();
    

    public static void main(String[] args){
        List<String> palavras = new ArrayList();
        ArrayList<Integer> index = new ArrayList<>();
        float corte = (float) 0.9;
        
      //  palavras.add("bola");
        //palavras.add("bola1");
        //palavras.add("bola2");
       // palavras.add("bola3");
      //  palavras.add("bola4");
       // 
        System.out.println(contem("bola2",palavras, corte));
        
       // adicionarPalavra("bola5", palavras, index, corte);
      //   adicionarPalavra("bola5", palavras, index, corte);
       //   adicionarPalavra("bola6", palavras, index, corte);
        
        for(int i=0;i<palavras.size();i++){
            System.out.println(palavras.get(i));
        }
        
         for(int i=0;i<index.size();i++){
            System.out.println(index.get(i));
        }
    }
    
    private static boolean LCSMatch(String x, String y, float corte) {
       int m = x.length();
       int n = y.length();
       int casamento;
       int maxtamanho;
       boolean flag;
       
       x.toLowerCase();
       y.toLowerCase();
       
       int[][] c = new int[m + 1][n + 1];
       for (int i = 1; i <= m; i++) {
           for (int j = 1; j <= n; j++) {
               if (x.charAt(i - 1) == y.charAt(j - 1)) {
                   c[i][j] = c[i - 1][j - 1] + 1;
               } else if (c[i - 1][j] >= c[i][j - 1]) {
                   c[i][j] = c[i - 1][j];
               } else {
                   c[i][j] = c[i][j - 1];
               }
           }
       }
       casamento = c[m][n];
       maxtamanho = Math.max(x.length(), y.length());

       
       if ((( (float) casamento / maxtamanho) >= corte )) {
       // System.out.println("As palavras são "+((float) casamento / maxtamanho)+" iguais");
            
                      flag=true;
                      
                  }else{
                     flag=false;
                  } 
       
       return flag;
       
   }
    
    private static int contem(String palavra1, List<String> palavras, float corte){
        String palavra2;
        int index = -1;
        for (int a = 0; a < palavras.size(); a++) {

            //captura a palavra "a" do index global
            palavra2 = palavras.get(a);


            //compara a palavra 1 com a 2
            if (LCSMatch(palavra1, palavra2, corte)) {
                //igual
                index = a;
                a = palavras.size();

            }
        }
        
        return index;

    }
    
    private static void adicionarPalavra(String palavra1, List<String> palavras, ArrayList<Integer> index, float corte){
                //percorre o index global da função "i"
                        int ind;
                        
                        //a palavra 1 contem no list global com o corte lcs?
                        ind = contem(palavra1,palavras,corte);
                        
                        if(ind!=-1){
                            if (!index.contains(ind)) {
                                index.add(ind);
                            }
                        }else{
                            int indexaux = palavras.size();
                            palavras.add(palavra1);
                           // index.add(palavras.indexOf(palavra1));
                            index.add(indexaux);
                      
                        }
                            
    }
    
    public void filtrar(ArrayList<Gene> info, float[] vcorte, ArrayList<Integer> verif) {
       
        Gene gene = new Gene();
        //Adicionar valores no Vector global
        String palavra1 = "";
       // float[] vcorte = new float[gene.getArrayTitulo().size()];
        try {
            //percorre todas as infos do gene
            for (int i = 0; i < gene.getArrayInfo().size(); i++) {
               
                //adiciona um array global por função
                List<String> palavras = new ArrayList<>();
                ArrayList<List<Integer>> arrayIndex = new ArrayList<>();
                
                //For para percorrer o array do gene
                for (int p = 0; p < info.size(); p++) {
                    //zera array aux do index
                    ArrayList<Integer> index = new ArrayList<>();
                    
                    //percorre a função "i" do gene "p"
                    for (int v = 0; v < info.get(p).getArrayInfo().get(i).size(); v++) {
                        //captura a palavra "v" da informação "i" do gene "p"
                        // gene    //array de info  //info //palavra info
                        palavra1 = info.get(p).getArrayInfo().get(i).get(v);
                        
                        //adciona as info globais na array palavras e coloca os index no array index
                        try {
                            adicionarPalavra(palavra1, palavras, index, (float) vcorte[i]);
                        } catch (Exception e) {
                            System.out.println(e);
                            System.out.println("Erro ao adicionar palavra");
                        };
                       //  adicionarPalavra(palavra1, palavras, index, (float)0.0);

                    }
                    //adicinar index do gene p da info i no array
                    arrayIndex.add(index);
                }
                
                //guardar vetor globar da info i
                global.add(palavras);
                
                //guardar indexs dos genes referente a info i
               no.add(arrayIndex);


            }
        } catch (Exception e) {
            System.out.println(e);
            System.out.println("Erro ao Filtrar");
        }
    }
    
    public void imprimirGlobal() {
        Gene gene = new Gene();
        //Percorre as informações
        for (int i = 0; i < global.size(); i++) {
            System.out.println(i+" - "+gene.getArrayTitulo().get(i));
            //escreve o conteudo da informação
            for (int j = 0; j < global.get(i).size(); j ++) {
                System.out.println(global.get(i).get(j));
            }
            System.out.println("------------------------------------");
        }
    }
    
    public void imprimirIndex(){
        Gene gene = new Gene();
        //percorre as informações
        for (int i = 0; i < no.size(); i++) {
            System.out.println(i+" - "+gene.getArrayTitulo().get(i));
           //percorre os genes
            for (int j = 0; j < no.get(i).size(); j ++) {
                System.out.println("******************************");
                System.out.println("Gene "+j);
                //escreve as informações
                for(int k = 0;k<no.get(i).get(j).size();k++){
                    System.out.println(no.get(i).get(j).get(k));
                }
                System.out.println("******************************");
            }
            System.out.println("------------------------------------");
        }
    }
    
    public void imprimirArestas(){
        Gene gene = new Gene();   
        for (int i = 0; i < no.size(); i++) {
            System.out.println(i+" - "+gene.getArrayTitulo().get(i));
            
            //percorre os genes
            for (int j = 0; j < no.get(i).size(); j ++) {
             ///   System.out.println("******************************");
               // System.out.println("Gene "+j);
                //escreve as informações
                for(int k = 0;k<no.get(i).get(j).size();k++){
                    int info = no.get(i).get(j).get(k);
                    
                    for(int l = 0; l < no.get(i).size(); l ++){
                        if(!no.get(i).get(l).isEmpty()){
                        if(no.get(i).get(l).contains(info)){
                          
                            System.out.println("Gene "+j+" - "+"Gene "+l);
                        }
                        }
                    }
                    
                    
                }
                //System.out.println("******************************");
           
            
            }
            //System.out.println("------------------------------------");
        }
    }
     
    public ArrayList<List<String>> getGlobal() {
        return global;
    }

    public void setGlobal(ArrayList<List<String>> global) {
        this.global = global;
    }

    public ArrayList<List<List<Integer>>> getNo() {
        return no;
    }

    public void setNo(ArrayList<List<List<Integer>>> no) {
        this.no = no;
    }

}

